home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / gas_251.zip / bin_251 / bfd / sunos.c < prev    next >
C/C++ Source or Header  |  1994-07-12  |  64KB  |  2,076 lines
  1. /* BFD backend for SunOS binaries.
  2.    Copyright (C) 1990, 91, 92, 93, 94 Free Software Foundation, Inc.
  3.    Written by Cygnus Support.
  4.  
  5. This file is part of BFD, the Binary File Descriptor library.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. #define TARGETNAME "a.out-sunos-big"
  22. #define MY(OP) CAT(sunos_big_,OP)
  23.  
  24. #include "bfd.h"
  25. #include "bfdlink.h"
  26. #include "libaout.h"
  27.  
  28. /* Static routines defined in this file.  */
  29.  
  30. static boolean sunos_read_dynamic_info PARAMS ((bfd *));
  31. static long sunos_get_dynamic_symtab_upper_bound PARAMS ((bfd *));
  32. static long sunos_canonicalize_dynamic_symtab PARAMS ((bfd *, asymbol **));
  33. static long sunos_get_dynamic_reloc_upper_bound PARAMS ((bfd *));
  34. static long sunos_canonicalize_dynamic_reloc
  35.   PARAMS ((bfd *, arelent **, asymbol **));
  36. static struct bfd_hash_entry *sunos_link_hash_newfunc
  37.   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  38. static struct bfd_link_hash_table *sunos_link_hash_table_create
  39.   PARAMS ((bfd *));
  40. static boolean sunos_add_dynamic_symbols
  41.   PARAMS ((bfd *, struct bfd_link_info *));
  42. static boolean sunos_add_one_symbol
  43.   PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,
  44.        bfd_vma, const char *, boolean, boolean,
  45.        struct bfd_link_hash_entry **));
  46. static boolean sunos_scan_relocs
  47.   PARAMS ((struct bfd_link_info *, bfd *, asection *, bfd_size_type));
  48. static boolean sunos_scan_std_relocs
  49.   PARAMS ((struct bfd_link_info *, bfd *, asection *,
  50.        const struct reloc_std_external *, bfd_size_type));
  51. static boolean sunos_scan_ext_relocs
  52.   PARAMS ((struct bfd_link_info *, bfd *, asection *,
  53.        const struct reloc_ext_external *, bfd_size_type));
  54. static boolean sunos_link_dynamic_object
  55.   PARAMS ((struct bfd_link_info *, bfd *));
  56. static boolean sunos_write_dynamic_symbol
  57.   PARAMS ((bfd *, struct bfd_link_info *, struct aout_link_hash_entry *));
  58. static boolean sunos_check_dynamic_reloc
  59.   PARAMS ((struct bfd_link_info *, bfd *, asection *,
  60.        struct aout_link_hash_entry *, PTR, boolean *));
  61. static boolean sunos_finish_dynamic_link
  62.   PARAMS ((bfd *, struct bfd_link_info *));
  63.  
  64. #define MY_get_dynamic_symtab_upper_bound sunos_get_dynamic_symtab_upper_bound
  65. #define MY_canonicalize_dynamic_symtab sunos_canonicalize_dynamic_symtab
  66. #define MY_get_dynamic_reloc_upper_bound sunos_get_dynamic_reloc_upper_bound
  67. #define MY_canonicalize_dynamic_reloc sunos_canonicalize_dynamic_reloc
  68. #define MY_bfd_link_hash_table_create sunos_link_hash_table_create
  69. #define MY_add_dynamic_symbols sunos_add_dynamic_symbols
  70. #define MY_add_one_symbol sunos_add_one_symbol
  71. #define MY_link_dynamic_object sunos_link_dynamic_object
  72. #define MY_write_dynamic_symbol sunos_write_dynamic_symbol
  73. #define MY_check_dynamic_reloc sunos_check_dynamic_reloc
  74. #define MY_finish_dynamic_link sunos_finish_dynamic_link
  75.  
  76. /* Include the usual a.out support.  */
  77. #include "aoutf1.h"
  78.  
  79. /* SunOS shared library support.  We store a pointer to this structure
  80.    in obj_aout_dynamic_info (abfd).  */
  81.  
  82. struct sunos_dynamic_info
  83. {
  84.   /* Whether we found any dynamic information.  */
  85.   boolean valid;
  86.   /* Dynamic information.  */
  87.   struct internal_sun4_dynamic_link dyninfo;
  88.   /* Number of dynamic symbols.  */
  89.   long dynsym_count;
  90.   /* Read in nlists for dynamic symbols.  */
  91.   struct external_nlist *dynsym;
  92.   /* asymbol structures for dynamic symbols.  */
  93.   aout_symbol_type *canonical_dynsym;
  94.   /* Read in dynamic string table.  */
  95.   char *dynstr;
  96.   /* Number of dynamic relocs.  */
  97.   long dynrel_count;
  98.   /* Read in dynamic relocs.  This may be reloc_std_external or
  99.      reloc_ext_external.  */
  100.   PTR dynrel;
  101.   /* arelent structures for dynamic relocs.  */
  102.   arelent *canonical_dynrel;
  103. };
  104.  
  105. /* The hash table of dynamic symbols is composed of two word entries.
  106.    See include/aout/sun4.h for details.  */
  107.  
  108. #define HASH_ENTRY_SIZE (2 * BYTES_IN_WORD)
  109.  
  110. /* Read in the basic dynamic information.  This locates the __DYNAMIC
  111.    structure and uses it to find the dynamic_link structure.  It
  112.    creates and saves a sunos_dynamic_info structure.  If it can't find
  113.    __DYNAMIC, it sets the valid field of the sunos_dynamic_info
  114.    structure to false to avoid doing this work again.  */
  115.  
  116. static boolean
  117. sunos_read_dynamic_info (abfd)
  118.      bfd *abfd;
  119. {
  120.   struct sunos_dynamic_info *info;
  121.   asection *dynsec;
  122.   file_ptr dynoff;
  123.   struct external_sun4_dynamic dyninfo;
  124.   unsigned long dynver;
  125.   struct external_sun4_dynamic_link linkinfo;
  126.  
  127.   if (obj_aout_dynamic_info (abfd) != (PTR) NULL)
  128.     return true;
  129.  
  130.   if ((abfd->flags & DYNAMIC) == 0)
  131.     {
  132.       bfd_set_error (bfd_error_invalid_operation);
  133.       return false;
  134.     }
  135.  
  136.   info = ((struct sunos_dynamic_info *)
  137.       bfd_zalloc (abfd, sizeof (struct sunos_dynamic_info)));
  138.   if (!info)
  139.     {
  140.       bfd_set_error (bfd_error_no_memory);
  141.       return false;
  142.     }
  143.   info->valid = false;
  144.   info->dynsym = NULL;
  145.   info->dynstr = NULL;
  146.   info->canonical_dynsym = NULL;
  147.   info->dynrel = NULL;
  148.   info->canonical_dynrel = NULL;
  149.   obj_aout_dynamic_info (abfd) = (PTR) info;
  150.  
  151.   /* This code used to look for the __DYNAMIC symbol to locate the dynamic
  152.      linking information.
  153.      However this inhibits recovering the dynamic symbols from a
  154.      stripped object file, so blindly assume that the dynamic linking
  155.      information is located at the start of the data section.
  156.      We could verify this assumption later by looking through the dynamic
  157.      symbols for the __DYNAMIC symbol.  */
  158.   if ((abfd->flags & DYNAMIC) == 0)
  159.     return true;
  160.   if (! bfd_get_section_contents (abfd, obj_datasec (abfd), (PTR) &dyninfo,
  161.                   (file_ptr) 0, sizeof dyninfo))
  162.     return true;
  163.  
  164.   dynver = GET_WORD (abfd, dyninfo.ld_version);
  165.   if (dynver != 2 && dynver != 3)
  166.     return true;
  167.  
  168.   dynoff = GET_WORD (abfd, dyninfo.ld);
  169.  
  170.   /* dynoff is a virtual address.  It is probably always in the .data
  171.      section, but this code should work even if it moves.  */
  172.   if (dynoff < bfd_get_section_vma (abfd, obj_datasec (abfd)))
  173.     dynsec = obj_textsec (abfd);
  174.   else
  175.     dynsec = obj_datasec (abfd);
  176.   dynoff -= bfd_get_section_vma (abfd, dynsec);
  177.   if (dynoff < 0 || dynoff > bfd_section_size (abfd, dynsec))
  178.     return true;
  179.  
  180.   /* This executable appears to be dynamically linked in a way that we
  181.      can understand.  */
  182.   if (! bfd_get_section_contents (abfd, dynsec, (PTR) &linkinfo, dynoff,
  183.                   (bfd_size_type) sizeof linkinfo))
  184.     return true;
  185.  
  186.   /* Swap in the dynamic link information.  */
  187.   info->dyninfo.ld_loaded = GET_WORD (abfd, linkinfo.ld_loaded);
  188.   info->dyninfo.ld_need = GET_WORD (abfd, linkinfo.ld_need);
  189.   info->dyninfo.ld_rules = GET_WORD (abfd, linkinfo.ld_rules);
  190.   info->dyninfo.ld_got = GET_WORD (abfd, linkinfo.ld_got);
  191.   info->dyninfo.ld_plt = GET_WORD (abfd, linkinfo.ld_plt);
  192.   info->dyninfo.ld_rel = GET_WORD (abfd, linkinfo.ld_rel);
  193.   info->dyninfo.ld_hash = GET_WORD (abfd, linkinfo.ld_hash);
  194.   info->dyninfo.ld_stab = GET_WORD (abfd, linkinfo.ld_stab);
  195.   info->dyninfo.ld_stab_hash = GET_WORD (abfd, linkinfo.ld_stab_hash);
  196.   info->dyninfo.ld_buckets = GET_WORD (abfd, linkinfo.ld_buckets);
  197.   info->dyninfo.ld_symbols = GET_WORD (abfd, linkinfo.ld_symbols);
  198.   info->dyninfo.ld_symb_size = GET_WORD (abfd, linkinfo.ld_symb_size);
  199.   info->dyninfo.ld_text = GET_WORD (abfd, linkinfo.ld_text);
  200.   info->dyninfo.ld_plt_sz = GET_WORD (abfd, linkinfo.ld_plt_sz);
  201.  
  202.   /* The only way to get the size of the symbol information appears to
  203.      be to determine the distance between it and the string table.  */
  204.   info->dynsym_count = ((info->dyninfo.ld_symbols - info->dyninfo.ld_stab)
  205.             / EXTERNAL_NLIST_SIZE);
  206.   BFD_ASSERT (info->dynsym_count * EXTERNAL_NLIST_SIZE
  207.           == info->dyninfo.ld_symbols - info->dyninfo.ld_stab);
  208.  
  209.   /* Similarly, the relocs end at the hash table.  */
  210.   info->dynrel_count = ((info->dyninfo.ld_hash - info->dyninfo.ld_rel)
  211.             / obj_reloc_entry_size (abfd));
  212.   BFD_ASSERT (info->dynrel_count * obj_reloc_entry_size (abfd)
  213.           == info->dyninfo.ld_hash - info->dyninfo.ld_rel);
  214.  
  215.   info->valid = true;
  216.  
  217.   return true;
  218. }
  219.  
  220. /* Return the amount of memory required for the dynamic symbols.  */
  221.  
  222. static long
  223. sunos_get_dynamic_symtab_upper_bound (abfd)
  224.      bfd *abfd;
  225. {
  226.   struct sunos_dynamic_info *info;
  227.  
  228.   if (! sunos_read_dynamic_info (abfd))
  229.     return -1;
  230.  
  231.   info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
  232.   if (! info->valid)
  233.     {
  234.       bfd_set_error (bfd_error_no_symbols);
  235.       return -1;
  236.     }
  237.  
  238.   return (info->dynsym_count + 1) * sizeof (asymbol *);
  239. }
  240.  
  241. /* Read in the dynamic symbols.  */
  242.  
  243. static long
  244. sunos_canonicalize_dynamic_symtab (abfd, storage)
  245.      bfd *abfd;
  246.      asymbol **storage;
  247. {
  248.   struct sunos_dynamic_info *info;
  249.   long i;
  250.  
  251.   /* Get the general dynamic information.  */
  252.   if (obj_aout_dynamic_info (abfd) == NULL)
  253.     {
  254.       if (! sunos_read_dynamic_info (abfd))
  255.       return -1;
  256.     }
  257.  
  258.   info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
  259.   if (! info->valid)
  260.     {
  261.       bfd_set_error (bfd_error_no_symbols);
  262.       return -1;
  263.     }
  264.  
  265.   /* Get the dynamic nlist structures.  */
  266.   if (info->dynsym == (struct external_nlist *) NULL)
  267.     {
  268.       info->dynsym = ((struct external_nlist *)
  269.               bfd_alloc (abfd,
  270.                  (info->dynsym_count
  271.                   * EXTERNAL_NLIST_SIZE)));
  272.       if (info->dynsym == NULL && info->dynsym_count != 0)
  273.     {
  274.       bfd_set_error (bfd_error_no_memory);
  275.       return -1;
  276.     }
  277.       if (bfd_seek (abfd, info->dyninfo.ld_stab, SEEK_SET) != 0
  278.       || (bfd_read ((PTR) info->dynsym, info->dynsym_count,
  279.             EXTERNAL_NLIST_SIZE, abfd)
  280.           != info->dynsym_count * EXTERNAL_NLIST_SIZE))
  281.     {
  282.       if (info->dynsym != NULL)
  283.         {
  284.           bfd_release (abfd, info->dynsym);
  285.           info->dynsym = NULL;
  286.         }
  287.       return -1;
  288.     }
  289.     }
  290.  
  291.   /* Get the dynamic strings.  */
  292.   if (info->dynstr == (char *) NULL)
  293.     {
  294.       info->dynstr = (char *) bfd_alloc (abfd, info->dyninfo.ld_symb_size);
  295.       if (info->dynstr == NULL && info->dyninfo.ld_symb_size != 0)
  296.     {
  297.       bfd_set_error (bfd_error_no_memory);
  298.       return -1;
  299.     }
  300.       if (bfd_seek (abfd, info->dyninfo.ld_symbols, SEEK_SET) != 0
  301.       || (bfd_read ((PTR) info->dynstr, 1, info->dyninfo.ld_symb_size,
  302.             abfd)
  303.           != info->dyninfo.ld_symb_size))
  304.     {
  305.       if (info->dynstr != NULL)
  306.         {
  307.           bfd_release (abfd, info->dynstr);
  308.           info->dynstr = NULL;
  309.         }
  310.       return -1;
  311.     }
  312.     }
  313.  
  314. #ifdef CHECK_DYNAMIC_HASH
  315.   /* Check my understanding of the dynamic hash table by making sure
  316.      that each symbol can be located in the hash table.  */
  317.   {
  318.     bfd_size_type table_size;
  319.     bfd_byte *table;
  320.     bfd_size_type i;
  321.  
  322.     if (info->dyninfo.ld_buckets > info->dynsym_count)
  323.       abort ();
  324.     table_size = info->dyninfo.ld_stab - info->dyninfo.ld_hash;
  325.     table = (bfd_byte *) malloc (table_size);
  326.     if (table == NULL && table_size != 0)
  327.       abort ();
  328.     if (bfd_seek (abfd, info->dyninfo.ld_hash, SEEK_SET) != 0
  329.     || bfd_read ((PTR) table, 1, table_size, abfd) != table_size)
  330.       abort ();
  331.     for (i = 0; i < info->dynsym_count; i++)
  332.       {
  333.     unsigned char *name;
  334.     unsigned long hash;
  335.  
  336.     name = ((unsigned char *) info->dynstr
  337.         + GET_WORD (abfd, info->dynsym[i].e_strx));
  338.     hash = 0;
  339.     while (*name != '\0')
  340.       hash = (hash << 1) + *name++;
  341.     hash &= 0x7fffffff;
  342.     hash %= info->dyninfo.ld_buckets;
  343.     while (GET_WORD (abfd, table + hash * HASH_ENTRY_SIZE) != i)
  344.       {
  345.         hash = GET_WORD (abfd,
  346.                  table + hash * HASH_ENTRY_SIZE + BYTES_IN_WORD);
  347.         if (hash == 0 || hash >= table_size / HASH_ENTRY_SIZE)
  348.           abort ();
  349.       }
  350.       }
  351.     free (table);
  352.   }
  353. #endif /* CHECK_DYNAMIC_HASH */
  354.  
  355.   /* Get the asymbol structures corresponding to the dynamic nlist
  356.      structures.  */
  357.   if (info->canonical_dynsym == (aout_symbol_type *) NULL)
  358.     {
  359.       info->canonical_dynsym = ((aout_symbol_type *)
  360.                 bfd_alloc (abfd,
  361.                        (info->dynsym_count
  362.                         * sizeof (aout_symbol_type))));
  363.       if (info->canonical_dynsym == NULL && info->dynsym_count != 0)
  364.     {
  365.       bfd_set_error (bfd_error_no_memory);
  366.       return -1;
  367.     }
  368.  
  369.       if (! aout_32_translate_symbol_table (abfd, info->canonical_dynsym,
  370.                         info->dynsym, info->dynsym_count,
  371.                         info->dynstr,
  372.                         info->dyninfo.ld_symb_size,
  373.                         true))
  374.     {
  375.       if (info->canonical_dynsym != NULL)
  376.         {
  377.           bfd_release (abfd, info->canonical_dynsym);
  378.           info->canonical_dynsym = NULL;
  379.         }
  380.       return -1;
  381.     }
  382.     }
  383.  
  384.   /* Return pointers to the dynamic asymbol structures.  */
  385.   for (i = 0; i < info->dynsym_count; i++)
  386.     *storage++ = (asymbol *) (info->canonical_dynsym + i);
  387.   *storage = NULL;
  388.  
  389.   return info->dynsym_count;
  390. }
  391.  
  392. /* Return the amount of memory required for the dynamic relocs.  */
  393.  
  394. static long
  395. sunos_get_dynamic_reloc_upper_bound (abfd)
  396.      bfd *abfd;
  397. {
  398.   struct sunos_dynamic_info *info;
  399.  
  400.   if (! sunos_read_dynamic_info (abfd))
  401.     return -1;
  402.  
  403.   info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
  404.   if (! info->valid)
  405.     {
  406.       bfd_set_error (bfd_error_no_symbols);
  407.       return -1;
  408.     }
  409.  
  410.   return (info->dynrel_count + 1) * sizeof (arelent *);
  411. }
  412.  
  413. /* Read in the dynamic relocs.  */
  414.  
  415. static long
  416. sunos_canonicalize_dynamic_reloc (abfd, storage, syms)
  417.      bfd *abfd;
  418.      arelent **storage;
  419.      asymbol **syms;
  420. {
  421.   struct sunos_dynamic_info *info;
  422.   long i;
  423.  
  424.   /* Get the general dynamic information.  */
  425.   if (obj_aout_dynamic_info (abfd) == (PTR) NULL)
  426.     {
  427.       if (! sunos_read_dynamic_info (abfd))
  428.     return -1;
  429.     }
  430.  
  431.   info = (struct sunos_dynamic_info *) obj_aout_dynamic_info (abfd);
  432.   if (! info->valid)
  433.     {
  434.       bfd_set_error (bfd_error_no_symbols);
  435.       return -1;
  436.     }
  437.  
  438.   /* Get the dynamic reloc information.  */
  439.   if (info->dynrel == NULL)
  440.     {
  441.       info->dynrel = (PTR) bfd_alloc (abfd,
  442.                       (info->dynrel_count
  443.                        * obj_reloc_entry_size (abfd)));
  444.       if (info->dynrel == NULL && info->dynrel_count != 0)
  445.     {
  446.       bfd_set_error (bfd_error_no_memory);
  447.       return -1;
  448.     }
  449.       if (bfd_seek (abfd, info->dyninfo.ld_rel, SEEK_SET) != 0
  450.       || (bfd_read ((PTR) info->dynrel, info->dynrel_count,
  451.             obj_reloc_entry_size (abfd), abfd)
  452.           != info->dynrel_count * obj_reloc_entry_size (abfd)))
  453.     {
  454.       if (info->dynrel != NULL)
  455.         {
  456.           bfd_release (abfd, info->dynrel);
  457.           info->dynrel = NULL;
  458.         }
  459.       return -1;
  460.     }
  461.     }
  462.  
  463.   /* Get the arelent structures corresponding to the dynamic reloc
  464.      information.  */
  465.   if (info->canonical_dynrel == (arelent *) NULL)
  466.     {
  467.       arelent *to;
  468.  
  469.       info->canonical_dynrel = ((arelent *)
  470.                 bfd_alloc (abfd,
  471.                        (info->dynrel_count
  472.                         * sizeof (arelent))));
  473.       if (info->canonical_dynrel == NULL && info->dynrel_count != 0)
  474.     {
  475.       bfd_set_error (bfd_error_no_memory);
  476.       return -1;
  477.     }
  478.       
  479.       to = info->canonical_dynrel;
  480.  
  481.       if (obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE)
  482.     {
  483.       register struct reloc_ext_external *p;
  484.       struct reloc_ext_external *pend;
  485.  
  486.       p = (struct reloc_ext_external *) info->dynrel;
  487.       pend = p + info->dynrel_count;
  488.       for (; p < pend; p++, to++)
  489.         NAME(aout,swap_ext_reloc_in) (abfd, p, to, syms);
  490.     }
  491.       else
  492.     {
  493.       register struct reloc_std_external *p;
  494.       struct reloc_std_external *pend;
  495.  
  496.       p = (struct reloc_std_external *) info->dynrel;
  497.       pend = p + info->dynrel_count;
  498.       for (; p < pend; p++, to++)
  499.         NAME(aout,swap_std_reloc_in) (abfd, p, to, syms);
  500.     }
  501.     }
  502.  
  503.   /* Return pointers to the dynamic arelent structures.  */
  504.   for (i = 0; i < info->dynrel_count; i++)
  505.     *storage++ = info->canonical_dynrel + i;
  506.   *storage = NULL;
  507.  
  508.   return info->dynrel_count;
  509. }
  510.  
  511. /* Code to handle linking of SunOS shared libraries.  */
  512.  
  513. /* A SPARC procedure linkage table entry is 12 bytes.  The first entry
  514.    in the table is a jump which is filled in by the runtime linker.
  515.    The remaining entries are branches back to the first entry,
  516.    followed by an index into the relocation table encoded to look like
  517.    a sethi of %g0.  */
  518.  
  519. #define SPARC_PLT_ENTRY_SIZE (12)
  520.  
  521. static bfd_byte sparc_plt_first_entry[SPARC_PLT_ENTRY_SIZE] =
  522. {
  523.   /* sethi %hi(0),%g1; address filled in by runtime linker.  */
  524.   0x3, 0, 0, 0,
  525.   /* jmp %g1; offset filled in by runtime linker.  */
  526.   0x81, 0xc0, 0x60, 0,
  527.   /* nop */
  528.   0x1, 0, 0, 0
  529. };
  530.  
  531. /* save %sp, -96, %sp */
  532. #define SPARC_PLT_ENTRY_WORD0 0x9de3bfa0
  533. /* call; address filled in later.  */
  534. #define SPARC_PLT_ENTRY_WORD1 0x40000000
  535. /* sethi; reloc index filled in later.  */
  536. #define SPARC_PLT_ENTRY_WORD2 0x01000000
  537.  
  538. /* An m68k procedure linkage table entry is 8 bytes.  The first entry
  539.    in the table is a jump which is filled in the by the runtime
  540.    linker.  The remaining entries are branches back to the first
  541.    entry, followed by a two byte index into the relocation table.  */
  542.  
  543. #define M68K_PLT_ENTRY_SIZE (8)
  544.  
  545. static bfd_byte m68k_plt_first_entry[M68K_PLT_ENTRY_SIZE] =
  546. {
  547.   /* jmps @# */
  548.   0x4e, 0xf9,
  549.   /* Filled in by runtime linker with a magic address.  */
  550.   0, 0, 0, 0,
  551.   /* Not used?  */
  552.   0, 0
  553. };
  554.  
  555. /* bsrl */
  556. #define M68K_PLT_ENTRY_WORD0 (0x61ff)
  557. /* Remaining words filled in later.  */
  558.  
  559. /* An entry in the SunOS linker hash table.  */
  560.  
  561. struct sunos_link_hash_entry
  562. {
  563.   struct aout_link_hash_entry root;
  564.  
  565.   /* If this is a dynamic symbol, this is its index into the dynamic
  566.      symbol table.  This is initialized to -1.  As the linker looks at
  567.      the input files, it changes this to -2 if it will be added to the
  568.      dynamic symbol table.  After all the input files have been seen,
  569.      the linker will know whether to build a dynamic symbol table; if
  570.      it does build one, this becomes the index into the table.  */
  571.   long dynindx;
  572.  
  573.   /* If this is a dynamic symbol, this is the index of the name in the
  574.      dynamic symbol string table.  */
  575.   long dynstr_index;
  576.  
  577.   /* Some linker flags.  */
  578.   unsigned char flags;
  579.   /* Symbol is referenced by a regular object.  */
  580. #define SUNOS_REF_REGULAR 01
  581.   /* Symbol is defined by a regular object.  */
  582. #define SUNOS_DEF_REGULAR 02
  583.   /* Symbol is referenced by a dynamic object.  */
  584. #define SUNOS_REF_DYNAMIC 010
  585.   /* Symbol is defined by a dynamic object.  */
  586. #define SUNOS_DEF_DYNAMIC 020
  587. };
  588.  
  589. /* The SunOS linker hash table.  */
  590.  
  591. struct sunos_link_hash_table
  592. {
  593.   struct aout_link_hash_table root;
  594.  
  595.   /* The first dynamic object found during the link.  */
  596.   bfd *dynobj;
  597.  
  598.   /* The number of dynamic symbols.  */
  599.   size_t dynsymcount;
  600.  
  601.   /* The number of buckets in the hash table.  */
  602.   size_t bucketcount;
  603. };
  604.  
  605. /* Routine to create an entry in an SunOS link hash table.  */
  606.  
  607. static struct bfd_hash_entry *
  608. sunos_link_hash_newfunc (entry, table, string)
  609.      struct bfd_hash_entry *entry;
  610.      struct bfd_hash_table *table;
  611.      const char *string;
  612. {
  613.   struct sunos_link_hash_entry *ret = (struct sunos_link_hash_entry *) entry;
  614.  
  615.   /* Allocate the structure if it has not already been allocated by a
  616.      subclass.  */
  617.   if (ret == (struct sunos_link_hash_entry *) NULL)
  618.     ret = ((struct sunos_link_hash_entry *)
  619.        bfd_hash_allocate (table, sizeof (struct sunos_link_hash_entry)));
  620.   if (ret == (struct sunos_link_hash_entry *) NULL)
  621.     {
  622.       bfd_set_error (bfd_error_no_memory);
  623.       return (struct bfd_hash_entry *) ret;
  624.     }
  625.  
  626.   /* Call the allocation method of the superclass.  */
  627.   ret = ((struct sunos_link_hash_entry *)
  628.      NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret,
  629.                        table, string));
  630.   if (ret != NULL)
  631.     {
  632.       /* Set local fields.  */
  633.       ret->dynindx = -1;
  634.       ret->dynstr_index = -1;
  635.       ret->flags = 0;
  636.     }
  637.  
  638.   return (struct bfd_hash_entry *) ret;
  639. }
  640.  
  641. /* Create a SunOS link hash table.  */
  642.  
  643. static struct bfd_link_hash_table *
  644. sunos_link_hash_table_create (abfd)
  645.      bfd *abfd;
  646. {
  647.   struct sunos_link_hash_table *ret;
  648.  
  649.   ret = ((struct sunos_link_hash_table *)
  650.      malloc (sizeof (struct sunos_link_hash_table)));
  651.   if (ret == (struct sunos_link_hash_table *) NULL)
  652.     {
  653.       bfd_set_error (bfd_error_no_memory);
  654.       return (struct bfd_link_hash_table *) NULL;
  655.     }
  656.   if (! NAME(aout,link_hash_table_init) (&ret->root, abfd,
  657.                      sunos_link_hash_newfunc))
  658.     {
  659.       free (ret);
  660.       return (struct bfd_link_hash_table *) NULL;
  661.     }
  662.  
  663.   ret->dynobj = NULL;
  664.   ret->dynsymcount = 0;
  665.   ret->bucketcount = 0;
  666.  
  667.   return &ret->root.root;
  668. }
  669.  
  670. /* Look up an entry in an SunOS link hash table.  */
  671.  
  672. #define sunos_link_hash_lookup(table, string, create, copy, follow) \
  673.   ((struct sunos_link_hash_entry *) \
  674.    aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
  675.               (follow)))
  676.  
  677. /* Traverse a SunOS link hash table.  */
  678.  
  679. #define sunos_link_hash_traverse(table, func, info)            \
  680.   (aout_link_hash_traverse                        \
  681.    (&(table)->root,                            \
  682.     (boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func),    \
  683.     (info)))
  684.  
  685. /* Get the SunOS link hash table from the info structure.  This is
  686.    just a cast.  */
  687.  
  688. #define sunos_hash_table(p) ((struct sunos_link_hash_table *) ((p)->hash))
  689.  
  690. static boolean sunos_scan_dynamic_symbol
  691.   PARAMS ((struct sunos_link_hash_entry *, PTR));
  692.  
  693. /* Add dynamic symbols during a link.  This is called by the a.out
  694.    backend linker when it encounters an object with the DYNAMIC flag
  695.    set.  */
  696.  
  697. static boolean
  698. sunos_add_dynamic_symbols (abfd, info)
  699.      bfd *abfd;
  700.      struct bfd_link_info *info;
  701. {
  702.   asection *s;
  703.  
  704.   /* We do not want to include the sections in a dynamic object in the
  705.      output file.  We hack by simply clobbering the list of sections
  706.      in the BFD.  This could be handled more cleanly by, say, a new
  707.      section flag; the existing SEC_NEVER_LOAD flag is not the one we
  708.      want, because that one still implies that the section takes up
  709.      space in the output file.  */
  710.   abfd->sections = NULL;
  711.  
  712.   /* The native linker seems to just ignore dynamic objects when -r is
  713.      used.  */
  714.   if (info->relocateable)
  715.     return true;
  716.  
  717.   /* There's no hope of using a dynamic object which does not exactly
  718.      match the format of the output file.  */
  719.   if (info->hash->creator != abfd->xvec)
  720.     {
  721.       bfd_set_error (bfd_error_invalid_operation);
  722.       return false;
  723.     }
  724.  
  725.   /* If this is the first dynamic object, create some new sections to
  726.      hold dynamic linking information.  We need to put these sections
  727.      somewhere, and the first dynamic object is as good a place as
  728.      any.  The linker script will look for these special section names
  729.      and put them in the right place in the output file.  See
  730.      include/aout/sun4.h for more details of the dynamic linking
  731.      information.  */
  732.   if (sunos_hash_table (info)->dynobj == NULL)
  733.     {
  734.       flagword flags;
  735.       asection *sdyn;
  736.  
  737.       sunos_hash_table (info)->dynobj = abfd;
  738.       
  739.       flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
  740.  
  741.       /* The .dynamic section holds the basic dynamic information: the
  742.      sun4_dynamic structure, the dynamic debugger information, and
  743.      the sun4_dynamic_link structure.  */
  744.       s = bfd_make_section (abfd, ".dynamic");
  745.       if (s == NULL
  746.       || ! bfd_set_section_flags (abfd, s, flags)
  747.       || ! bfd_set_section_alignment (abfd, s, 2))
  748.      return false;
  749.       sdyn = s;
  750.  
  751.       /* The .need section holds the list of names of shared objets
  752.      which must be included at runtime.  The address of this
  753.      section is put in the ld_need field.  */
  754.       s = bfd_make_section (abfd, ".need");
  755.       if (s == NULL
  756.       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
  757.       || ! bfd_set_section_alignment (abfd, s, 2))
  758.     return false;
  759.  
  760.       /* The .rules section holds the path to search for shared
  761.      objects.  The address of this section is put in the ld_rules
  762.      field.  */
  763.       s = bfd_make_section (abfd, ".rules");
  764.       if (s == NULL
  765.       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
  766.       || ! bfd_set_section_alignment (abfd, s, 2))
  767.     return false;
  768.  
  769.       /* The .got section holds the global offset table.  I don't
  770.      really know how this works, actually.  It seems to only be
  771.      used for PIC code.  The address minus four is put in the
  772.      ld_got field.  */
  773.       s = bfd_make_section (abfd, ".got");
  774.       if (s == NULL
  775.       || ! bfd_set_section_flags (abfd, s, flags)
  776.       || ! bfd_set_section_alignment (abfd, s, 2))
  777.     return false;
  778.       s->_raw_size = BYTES_IN_WORD;
  779.  
  780.       /* The .plt section holds the procedure linkage table.  The
  781.      address is put in the ld_plt field.  */
  782.       s = bfd_make_section (abfd, ".plt");
  783.       if (s == NULL
  784.       || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
  785.       || ! bfd_set_section_alignment (abfd, s, 2))
  786.     return false;
  787.  
  788.       /* The .dynrel section holds the dynamic relocs.  The address is
  789.      put in the ld_rel field.  */
  790.       s = bfd_make_section (abfd, ".dynrel");
  791.       if (s == NULL
  792.       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
  793.       || ! bfd_set_section_alignment (abfd, s, 2))
  794.     return false;
  795.  
  796.       /* The .hash section holds the dynamic hash table.  The address
  797.      is put in the ld_hash field.  */
  798.       s = bfd_make_section (abfd, ".hash");
  799.       if (s == NULL
  800.       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
  801.       || ! bfd_set_section_alignment (abfd, s, 2))
  802.     return false;
  803.  
  804.       /* The .dynsym section holds the dynamic symbols.  The address
  805.      is put in the ld_stab field.  */
  806.       s = bfd_make_section (abfd, ".dynsym");
  807.       if (s == NULL
  808.       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
  809.       || ! bfd_set_section_alignment (abfd, s, 2))
  810.     return false;
  811.  
  812.       /* The .dynstr section holds the dynamic symbol string table.
  813.      The address is put in the ld_symbols field.  */
  814.       s = bfd_make_section (abfd, ".dynstr");
  815.       if (s == NULL
  816.       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
  817.       || ! bfd_set_section_alignment (abfd, s, 2))
  818.     return false;
  819.     }
  820.  
  821.   return true;
  822. }
  823.  
  824. /* Function to add a single symbol to the linker hash table.  This is
  825.    a wrapper around _bfd_generic_link_add_one_symbol which handles the
  826.    tweaking needed for dynamic linking support.  */
  827.  
  828. static boolean
  829. sunos_add_one_symbol (info, abfd, name, flags, section, value, string,
  830.               copy, collect, hashp)
  831.      struct bfd_link_info *info;
  832.      bfd *abfd;
  833.      const char *name;
  834.      flagword flags;
  835.      asection *section;
  836.      bfd_vma value;
  837.      const char *string;
  838.      boolean copy;
  839.      boolean collect;
  840.      struct bfd_link_hash_entry **hashp;
  841. {
  842.   struct sunos_link_hash_entry *h;
  843.   int new_flag;
  844.  
  845.   h = sunos_link_hash_lookup (sunos_hash_table (info), name, true, copy,
  846.                   false);
  847.   if (h == NULL)
  848.     return false;
  849.  
  850.   if (hashp != NULL)
  851.     *hashp = (struct bfd_link_hash_entry *) h;
  852.  
  853.   /* Treat a common symbol in a dynamic object as defined in the .bss
  854.      section of the dynamic object.  We don't want to allocate space
  855.      for it in our process image.  */
  856.   if ((abfd->flags & DYNAMIC) != 0
  857.       && bfd_is_com_section (section))
  858.     section = obj_bsssec (abfd);
  859.  
  860.   if (! bfd_is_und_section (section)
  861.       && h->root.root.type != bfd_link_hash_new
  862.       && h->root.root.type != bfd_link_hash_undefined)
  863.     {
  864.       /* We are defining the symbol, and it is already defined.  This
  865.      is a potential multiple definition error.  */
  866.       if ((abfd->flags & DYNAMIC) != 0)
  867.     {
  868.       /* The definition we are adding is from a dynamic object.
  869.          We do not want this new definition to override the
  870.          existing definition, so we pretend it is just a
  871.          reference.  */
  872.       section = bfd_und_section_ptr;
  873.     }
  874.       else if ((h->root.root.type == bfd_link_hash_defined
  875.         && (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0)
  876.            || (h->root.root.type == bfd_link_hash_common
  877.            && ((h->root.root.u.c.section->owner->flags & DYNAMIC)
  878.                != 0)))
  879.     {
  880.       /* The existing definition is from a dynamic object.  We
  881.          want to override it with the definition we just found.
  882.          Clobber the existing definition.  */
  883.       h->root.root.type = bfd_link_hash_new;
  884.     }
  885.     }
  886.  
  887.   /* Do the usual procedure for adding a symbol.  */
  888.   if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
  889.                       value, string, copy, collect,
  890.                       hashp))
  891.     return false;
  892.  
  893.   /* Set a flag in the hash table entry indicating the type of
  894.      reference or definition we just found.  Keep a count of the
  895.      number of dynamic symbols we find.  A dynamic symbol is one which
  896.      is referenced or defined by both a regular object and a shared
  897.      object.  */
  898.   if ((abfd->flags & DYNAMIC) == 0)
  899.     {
  900.       if (bfd_is_und_section (section))
  901.     new_flag = SUNOS_REF_REGULAR;
  902.       else
  903.     new_flag = SUNOS_DEF_REGULAR;
  904.     }
  905.   else
  906.     {
  907.       if (bfd_is_und_section (section))
  908.     new_flag = SUNOS_REF_DYNAMIC;
  909.       else
  910.     new_flag = SUNOS_DEF_DYNAMIC;
  911.     }
  912.   h->flags |= new_flag;
  913.  
  914.   if (h->dynindx == -1
  915.       && (h->flags & (SUNOS_DEF_REGULAR | SUNOS_REF_REGULAR)) != 0)
  916.     {
  917.       ++sunos_hash_table (info)->dynsymcount;
  918.       h->dynindx = -2;
  919.     }
  920.  
  921.   return true;
  922. }
  923.  
  924. /* Record an assignment made to a symbol by a linker script.  We need
  925.    this in case some dynamic object refers to this symbol.  */
  926.  
  927. boolean
  928. bfd_sunos_record_link_assignment (output_bfd, info, name)
  929.      bfd *output_bfd;
  930.      struct bfd_link_info *info;
  931.      const char *name;
  932. {
  933.   struct sunos_link_hash_entry *h;
  934.  
  935.   /* This is called after we have examined all the input objects.  If
  936.      the symbol does not exist, it merely means that no object refers
  937.      to it, and we can just ignore it at this point.  */
  938.   h = sunos_link_hash_lookup (sunos_hash_table (info), name,
  939.                   false, false, false);
  940.   if (h == NULL)
  941.     return true;
  942.  
  943.   h->flags |= SUNOS_DEF_REGULAR;
  944.  
  945.   if (h->dynindx == -1)
  946.     {
  947.       ++sunos_hash_table (info)->dynsymcount;
  948.       h->dynindx = -2;
  949.     }
  950.  
  951.   return true;
  952. }
  953.  
  954. /* Set up the sizes and contents of the dynamic sections created in
  955.    sunos_add_dynamic_symbols.  This is called by the SunOS linker
  956.    emulation before_allocation routine.  We must set the sizes of the
  957.    sections before the linker sets the addresses of the various
  958.    sections.  This unfortunately requires reading all the relocs so
  959.    that we can work out which ones need to become dynamic relocs.  If
  960.    info->keep_memory is true, we keep the relocs in memory; otherwise,
  961.    we discard them, and will read them again later.  */
  962.  
  963. boolean
  964. bfd_sunos_size_dynamic_sections (output_bfd, info, sdynptr, sneedptr,
  965.                  srulesptr)
  966.      bfd *output_bfd;
  967.      struct bfd_link_info *info;
  968.      asection **sdynptr;
  969.      asection **sneedptr;
  970.      asection **srulesptr;
  971. {
  972.   bfd *dynobj;
  973.   size_t dynsymcount;
  974.   asection *s;
  975.   size_t bucketcount;
  976.   size_t hashalloc;
  977.   size_t i;
  978.   bfd *sub;
  979.  
  980.   *sdynptr = NULL;
  981.   *sneedptr = NULL;
  982.   *srulesptr = NULL;
  983.  
  984.   dynobj = sunos_hash_table (info)->dynobj;
  985.   dynsymcount = sunos_hash_table (info)->dynsymcount;
  986.  
  987.   /* If there were no dynamic objects in the link, there is nothing to
  988.      do here.  */
  989.   if (dynobj == NULL)
  990.     return true;
  991.  
  992.   /* The .dynamic section is always the same size.  */
  993.   s = bfd_get_section_by_name (dynobj, ".dynamic");
  994.   BFD_ASSERT (s != NULL);
  995.   s->_raw_size = (sizeof (struct external_sun4_dynamic)
  996.           + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE
  997.           + sizeof (struct external_sun4_dynamic_link));
  998.  
  999.   /* Set the size of the .dynsym and .hash sections.  We counted the
  1000.      number of dynamic symbols as we read the input files.  We will
  1001.      build the dynamic symbol table (.dynsym) and the hash table
  1002.      (.hash) when we build the final symbol table, because until then
  1003.      we do not know the correct value to give the symbols.  We build
  1004.      the dynamic symbol string table (.dynstr) in a traversal of the
  1005.      symbol table using sunos_scan_dynamic_symbol.  */
  1006.   s = bfd_get_section_by_name (dynobj, ".dynsym");
  1007.   BFD_ASSERT (s != NULL);
  1008.   s->_raw_size = dynsymcount * sizeof (struct external_nlist);
  1009.   s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
  1010.   if (s->contents == NULL && s->_raw_size != 0)
  1011.     {
  1012.       bfd_set_error (bfd_error_no_memory);
  1013.       return false;
  1014.     }
  1015.       
  1016.   /* The number of buckets is just the number of symbols divided by
  1017.      four.  The compute the final size of the hash table, we must
  1018.      actually compute the hash table.  Normally we need exactly as
  1019.      many entries in the hash table as there are dynamic symbols, but
  1020.      if some of the buckets are not used we will need additional
  1021.      entries.  In the worse case, every symbol will hash to the same
  1022.      bucket, and we will need BUCKETCOUNT - 1 extra entries.  */
  1023.   if (dynsymcount >= 4)
  1024.     bucketcount = dynsymcount / 4;
  1025.   else if (dynsymcount > 0)
  1026.     bucketcount = dynsymcount;
  1027.   else
  1028.     bucketcount = 1;
  1029.   s = bfd_get_section_by_name (dynobj, ".hash");
  1030.   BFD_ASSERT (s != NULL);
  1031.   hashalloc = (dynsymcount + bucketcount - 1) * HASH_ENTRY_SIZE;
  1032.   s->contents = (bfd_byte *) bfd_alloc (dynobj, hashalloc);
  1033.   if (s->contents == NULL && dynsymcount > 0)
  1034.     {
  1035.       bfd_set_error (bfd_error_no_memory);
  1036.       return false;
  1037.     }
  1038.   memset (s->contents, 0, hashalloc);
  1039.   for (i = 0; i < bucketcount; i++)
  1040.     PUT_WORD (output_bfd, (bfd_vma) -1, s->contents + i * HASH_ENTRY_SIZE);
  1041.   s->_raw_size = bucketcount * HASH_ENTRY_SIZE;
  1042.  
  1043.   sunos_hash_table (info)->bucketcount = bucketcount;
  1044.  
  1045.   /* Look through all the input BFD's and read their relocs.  It would
  1046.      be better if we didn't have to do this, but there is no other way
  1047.      to determine the number of dynamic relocs we need, and, more
  1048.      importantly, there is no other way to know which symbols should
  1049.      get an entry in the procedure linkage table.  */
  1050.   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
  1051.     {
  1052.       if ((sub->flags & DYNAMIC) == 0)
  1053.     {
  1054.       if (! sunos_scan_relocs (info, sub, obj_textsec (sub),
  1055.                    exec_hdr (sub)->a_trsize)
  1056.           || ! sunos_scan_relocs (info, sub, obj_datasec (sub),
  1057.                       exec_hdr (sub)->a_drsize))
  1058.         return false;
  1059.     }
  1060.     }
  1061.  
  1062.   /* Scan all the symbols, place them in the dynamic symbol table, and
  1063.      build the dynamic hash table.  We reuse dynsymcount as a counter
  1064.      for the number of symbols we have added so far.  */
  1065.   sunos_hash_table (info)->dynsymcount = 0;
  1066.   sunos_link_hash_traverse (sunos_hash_table (info),
  1067.                 sunos_scan_dynamic_symbol,
  1068.                 (PTR) info);
  1069.   BFD_ASSERT (sunos_hash_table (info)->dynsymcount == dynsymcount);
  1070.  
  1071.   /* The SunOS native linker seems to align the total size of the
  1072.      symbol strings to a multiple of 8.  I don't know if this is
  1073.      important, but it can't hurt much.  */
  1074.   s = bfd_get_section_by_name (dynobj, ".dynstr");
  1075.   BFD_ASSERT (s != NULL);
  1076.   if ((s->_raw_size & 7) != 0)
  1077.     {
  1078.       bfd_size_type add;
  1079.       bfd_byte *contents;
  1080.  
  1081.       add = 8 - (s->_raw_size & 7);
  1082.       contents = (bfd_byte *) realloc (s->contents, s->_raw_size + add);
  1083.       if (contents == NULL)
  1084.     {
  1085.       bfd_set_error (bfd_error_no_memory);
  1086.       return false;
  1087.     }
  1088.       memset (contents + s->_raw_size, 0, add);
  1089.       s->contents = contents;
  1090.       s->_raw_size += add;
  1091.     }
  1092.  
  1093.   /* Now that we have worked out the sizes of the procedure linkage
  1094.      table and the dynamic relocs, allocate storage for them.  */
  1095.   s = bfd_get_section_by_name (dynobj, ".plt");
  1096.   BFD_ASSERT (s != NULL);
  1097.   if (s->_raw_size != 0)
  1098.     {
  1099.       s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
  1100.       if (s->contents == NULL)
  1101.     {
  1102.       bfd_set_error (bfd_error_no_memory);
  1103.       return false;
  1104.     }
  1105.  
  1106.       /* Fill in the first entry in the table.  */
  1107.       switch (bfd_get_arch (dynobj))
  1108.     {
  1109.     case bfd_arch_sparc:
  1110.       memcpy (s->contents, sparc_plt_first_entry, SPARC_PLT_ENTRY_SIZE);
  1111.       break;
  1112.  
  1113.     case bfd_arch_m68k:
  1114.       memcpy (s->contents, m68k_plt_first_entry, M68K_PLT_ENTRY_SIZE);
  1115.       break;
  1116.  
  1117.     default:
  1118.       abort ();
  1119.     }
  1120.     }
  1121.  
  1122.   s = bfd_get_section_by_name (dynobj, ".dynrel");
  1123.   if (s->_raw_size != 0)
  1124.     {
  1125.       s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
  1126.       if (s->contents == NULL)
  1127.     {
  1128.       bfd_set_error (bfd_error_no_memory);
  1129.       return false;
  1130.     }
  1131.     }
  1132.   /* We use the reloc_count field to keep track of how many of the
  1133.      relocs we have output so far.  */
  1134.   s->reloc_count = 0;
  1135.  
  1136.   /* Make space for the global offset table.  */
  1137.   s = bfd_get_section_by_name (dynobj, ".got");
  1138.   s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
  1139.   if (s->contents == NULL)
  1140.     {
  1141.       bfd_set_error (bfd_error_no_memory);
  1142.       return false;
  1143.     }
  1144.  
  1145.   *sdynptr = bfd_get_section_by_name (dynobj, ".dynamic");
  1146.   *sneedptr = bfd_get_section_by_name (dynobj, ".need");
  1147.   *srulesptr = bfd_get_section_by_name (dynobj, ".rules");
  1148.  
  1149.   return true;
  1150. }
  1151.  
  1152. /* Scan the relocs for an input section.  */
  1153.  
  1154. static boolean
  1155. sunos_scan_relocs (info, abfd, sec, rel_size)
  1156.      struct bfd_link_info *info;
  1157.      bfd *abfd;
  1158.      asection *sec;
  1159.      bfd_size_type rel_size;
  1160. {
  1161.   PTR relocs;
  1162.   PTR free_relocs = NULL;
  1163.  
  1164.   if (rel_size == 0)
  1165.     return true;
  1166.  
  1167.   if (! info->keep_memory)
  1168.     relocs = free_relocs = malloc (rel_size);
  1169.   else
  1170.     {
  1171.       aout_section_data (sec) =
  1172.     ((struct aout_section_data_struct *)
  1173.      bfd_alloc (abfd, sizeof (struct aout_section_data_struct)));
  1174.       if (aout_section_data (sec) == NULL)
  1175.     relocs = NULL;
  1176.       else
  1177.     relocs = aout_section_data (sec)->relocs = malloc (rel_size);
  1178.     }
  1179.   if (relocs == NULL)
  1180.     {
  1181.       bfd_set_error (bfd_error_no_memory);
  1182.       return false;
  1183.     }
  1184.  
  1185.   if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
  1186.       || bfd_read (relocs, 1, rel_size, abfd) != rel_size)
  1187.     goto error_return;
  1188.  
  1189.   if (obj_reloc_entry_size (abfd) == RELOC_STD_SIZE)
  1190.     {
  1191.       if (! sunos_scan_std_relocs (info, abfd, sec,
  1192.                    (struct reloc_std_external *) relocs,
  1193.                    rel_size))
  1194.     goto error_return;
  1195.     }
  1196.   else
  1197.     {
  1198.       if (! sunos_scan_ext_relocs (info, abfd, sec,
  1199.                    (struct reloc_ext_external *) relocs,
  1200.                    rel_size))
  1201.     goto error_return;
  1202.     }
  1203.  
  1204.   if (free_relocs != NULL)
  1205.     free (free_relocs);
  1206.  
  1207.   return true;
  1208.  
  1209.  error_return:
  1210.   if (free_relocs != NULL)
  1211.     free (free_relocs);
  1212.   return false;
  1213. }
  1214.  
  1215. /* Scan the relocs for an input section using standard relocs.  We
  1216.    need to figure out what to do for each reloc against a dynamic
  1217.    symbol.  If the symbol is in the .text section, an entry is made in
  1218.    the procedure linkage table.  Note that this will do the wrong
  1219.    thing if the symbol is actually data; I don't think the Sun 3
  1220.    native linker handles this case correctly either.  If the symbol is
  1221.    not in the .text section, we must preserve the reloc as a dynamic
  1222.    reloc.  FIXME: We should also handle the PIC relocs here by
  1223.    building global offset table entries.  */
  1224.  
  1225. static boolean
  1226. sunos_scan_std_relocs (info, abfd, sec, relocs, rel_size)
  1227.      struct bfd_link_info *info;
  1228.      bfd *abfd;
  1229.      asection *sec;
  1230.      const struct reloc_std_external *relocs;
  1231.      bfd_size_type rel_size;
  1232. {
  1233.   bfd *dynobj;
  1234.   asection *splt;
  1235.   asection *srel;
  1236.   struct sunos_link_hash_entry **sym_hashes;
  1237.   const struct reloc_std_external *rel, *relend;
  1238.  
  1239.   /* We only know how to handle m68k plt entries.  */
  1240.   if (bfd_get_arch (abfd) != bfd_arch_m68k)
  1241.     {
  1242.       bfd_set_error (bfd_error_invalid_target);
  1243.       return false;
  1244.     }
  1245.  
  1246.   dynobj = sunos_hash_table (info)->dynobj;
  1247.   splt = bfd_get_section_by_name (dynobj, ".plt");
  1248.   srel = bfd_get_section_by_name (dynobj, ".dynrel");
  1249.   BFD_ASSERT (splt != NULL && srel != NULL);
  1250.   sym_hashes = (struct sunos_link_hash_entry **) obj_aout_sym_hashes (abfd);
  1251.  
  1252.   relend = relocs + rel_size / RELOC_STD_SIZE;
  1253.   for (rel = relocs; rel < relend; rel++)
  1254.     {
  1255.       int r_index;
  1256.       struct sunos_link_hash_entry *h;
  1257.  
  1258.       /* We only want relocs against external symbols.  */
  1259.       if (abfd->xvec->header_byteorder_big_p)
  1260.     {
  1261.       if ((rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG) == 0)
  1262.         continue;
  1263.     }
  1264.       else
  1265.     {
  1266.       if ((rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE) == 0)
  1267.         continue;
  1268.     }
  1269.  
  1270.       /* Get the symbol index.  */
  1271.       if (abfd->xvec->header_byteorder_big_p)
  1272.     {
  1273.       r_index   =  ((rel->r_index[0] << 16)
  1274.             | (rel->r_index[1] << 8)
  1275.             | rel->r_index[2]);
  1276.     }
  1277.       else
  1278.     {
  1279.       r_index   = ((rel->r_index[2] << 16)
  1280.                | (rel->r_index[1] << 8)
  1281.                | rel->r_index[0]);
  1282.     }
  1283.  
  1284.       /* Get the hash table entry.  */
  1285.       h = sym_hashes[r_index];
  1286.       if (h == NULL)
  1287.     {
  1288.       /* This should not normally happen, but it will in any case
  1289.          be caught in the relocation phase.  */
  1290.       continue;
  1291.     }
  1292.  
  1293.       /* At this point common symbols have already been allocated, so
  1294.      we don't have to worry about them.  We need to consider that
  1295.      we may have already seen this symbol and marked it undefined;
  1296.      if the symbols is really undefined, then SUNOS_DEF_DYNAMIC
  1297.      will be zero.  */
  1298.       if (h->root.root.type != bfd_link_hash_defined
  1299.       && h->root.root.type != bfd_link_hash_undefined)
  1300.     continue;
  1301.  
  1302.       if ((h->flags & SUNOS_DEF_DYNAMIC) == 0
  1303.       || (h->flags & SUNOS_DEF_REGULAR) != 0)
  1304.     continue;
  1305.  
  1306.       BFD_ASSERT ((h->flags & SUNOS_REF_REGULAR) != 0);
  1307.       BFD_ASSERT (h->root.root.type == bfd_link_hash_defined
  1308.           ? (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0
  1309.           : (h->root.root.u.undef.abfd->flags & DYNAMIC) != 0);
  1310.  
  1311.       /* This reloc is against a symbol defined only by a dynamic
  1312.      object.  */
  1313.  
  1314.       if (h->root.root.type == bfd_link_hash_undefined)
  1315.     {
  1316.       /* Presumably this symbol was marked as being undefined by
  1317.          an earlier reloc.  */
  1318.       srel->_raw_size += RELOC_STD_SIZE;
  1319.     }
  1320.       else if ((h->root.root.u.def.section->flags & SEC_CODE) == 0)
  1321.     {
  1322.       bfd *sub;
  1323.  
  1324.       /* This reloc is not in the .text section.  It must be
  1325.          copied into the dynamic relocs.  We mark the symbol as
  1326.          being undefined.  */
  1327.       srel->_raw_size += RELOC_STD_SIZE;
  1328.       sub = h->root.root.u.def.section->owner;
  1329.       h->root.root.type = bfd_link_hash_undefined;
  1330.       h->root.root.u.undef.abfd = sub;
  1331.     }
  1332.       else
  1333.     {
  1334.       /* This symbol is in the .text section.  We must give it an
  1335.          entry in the procedure linkage table, if we have not
  1336.          already done so.  We change the definition of the symbol
  1337.          to the .plt section; this will cause relocs against it to
  1338.          be handled correctly.  */
  1339.       if (h->root.root.u.def.section != splt)
  1340.         {
  1341.           if (splt->_raw_size == 0)
  1342.         splt->_raw_size = M68K_PLT_ENTRY_SIZE;
  1343.           h->root.root.u.def.section = splt;
  1344.           h->root.root.u.def.value = splt->_raw_size;
  1345.           splt->_raw_size += M68K_PLT_ENTRY_SIZE;
  1346.  
  1347.           /* We will also need a dynamic reloc entry.  */
  1348.           srel->_raw_size += RELOC_STD_SIZE;
  1349.         }
  1350.     }
  1351.     }
  1352.  
  1353.   return true;
  1354. }
  1355.  
  1356. /* Scan the relocs for an input section using extended relocs.  We
  1357.    need to figure out what to do for each reloc against a dynamic
  1358.    symbol.  If the reloc is a WDISP30, and the symbol is in the .text
  1359.    section, an entry is made in the procedure linkage table.
  1360.    Otherwise, we must preserve the reloc as a dynamic reloc.  FIXME:
  1361.    We should also handle the PIC relocs here by building global offset
  1362.    table entries.  */
  1363.  
  1364. static boolean
  1365. sunos_scan_ext_relocs (info, abfd, sec, relocs, rel_size)
  1366.      struct bfd_link_info *info;
  1367.      bfd *abfd;
  1368.      asection *sec;
  1369.      const struct reloc_ext_external *relocs;
  1370.      bfd_size_type rel_size;
  1371. {
  1372.   bfd *dynobj;
  1373.   asection *splt;
  1374.   asection *srel;
  1375.   struct sunos_link_hash_entry **sym_hashes;
  1376.   const struct reloc_ext_external *rel, *relend;
  1377.  
  1378.   /* We only know how to handle SPARC plt entries.  */
  1379.   if (bfd_get_arch (abfd) != bfd_arch_sparc)
  1380.     {
  1381.       bfd_set_error (bfd_error_invalid_target);
  1382.       return false;
  1383.     }
  1384.  
  1385.   dynobj = sunos_hash_table (info)->dynobj;
  1386.   splt = bfd_get_section_by_name (dynobj, ".plt");
  1387.   srel = bfd_get_section_by_name (dynobj, ".dynrel");
  1388.   BFD_ASSERT (splt != NULL && srel != NULL);
  1389.   sym_hashes = (struct sunos_link_hash_entry **) obj_aout_sym_hashes (abfd);
  1390.  
  1391.   relend = relocs + rel_size / RELOC_EXT_SIZE;
  1392.   for (rel = relocs; rel < relend; rel++)
  1393.     {
  1394.       int r_index;
  1395.       int r_type;
  1396.       struct sunos_link_hash_entry *h;
  1397.  
  1398.       /* We only want relocs against external symbols.  */
  1399.       if (abfd->xvec->header_byteorder_big_p)
  1400.     {
  1401.       if ((rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG) == 0)
  1402.         continue;
  1403.     }
  1404.       else
  1405.     {
  1406.       if ((rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE) == 0)
  1407.         continue;
  1408.     }
  1409.  
  1410.       /* Get the symbol index and reloc type.  */
  1411.       if (abfd->xvec->header_byteorder_big_p)
  1412.     {
  1413.       r_index   =  ((rel->r_index[0] << 16)
  1414.             | (rel->r_index[1] << 8)
  1415.             | rel->r_index[2]);
  1416.       r_type   = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
  1417.               >> RELOC_EXT_BITS_TYPE_SH_BIG);
  1418.     }
  1419.       else
  1420.     {
  1421.       r_index   = ((rel->r_index[2] << 16)
  1422.                | (rel->r_index[1] << 8)
  1423.                | rel->r_index[0]);
  1424.       r_type   = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
  1425.               >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
  1426.     }
  1427.  
  1428.       /* Get the hash table entry.  */
  1429.       h = sym_hashes[r_index];
  1430.       if (h == NULL)
  1431.     {
  1432.       /* This should not normally happen, but it will in any case
  1433.          be caught in the relocation phase.  */
  1434.       continue;
  1435.     }
  1436.  
  1437.       /* At this point common symbols have already been allocated, so
  1438.      we don't have to worry about them.  We need to consider that
  1439.      we may have already seen this symbol and marked it undefined;
  1440.      if the symbols is really undefined, then SUNOS_DEF_DYNAMIC
  1441.      will be zero.  */
  1442.       if (h->root.root.type != bfd_link_hash_defined
  1443.       && h->root.root.type != bfd_link_hash_undefined)
  1444.     continue;
  1445.  
  1446.       if ((h->flags & SUNOS_DEF_DYNAMIC) == 0
  1447.       || (h->flags & SUNOS_DEF_REGULAR) != 0)
  1448.     continue;
  1449.  
  1450.       BFD_ASSERT ((h->flags & SUNOS_REF_REGULAR) != 0);
  1451.       BFD_ASSERT (h->root.root.type == bfd_link_hash_defined
  1452.           ? (h->root.root.u.def.section->owner->flags & DYNAMIC) != 0
  1453.           : (h->root.root.u.undef.abfd->flags & DYNAMIC) != 0);
  1454.  
  1455.       /* This reloc is against a symbol defined only by a dynamic
  1456.      object.  */
  1457.  
  1458.       if (h->root.root.type == bfd_link_hash_undefined)
  1459.     {
  1460.       /* Presumably this symbol was marked as being undefined by
  1461.          an earlier reloc.  */
  1462.       srel->_raw_size += RELOC_EXT_SIZE;
  1463.     }
  1464.       else if ((h->root.root.u.def.section->flags & SEC_CODE) == 0)
  1465.     {
  1466.       bfd *sub;
  1467.  
  1468.       /* This reloc is not in the .text section.  It must be
  1469.          copied into the dynamic relocs.  We mark the symbol as
  1470.          being undefined.  */
  1471.       srel->_raw_size += RELOC_EXT_SIZE;
  1472.       sub = h->root.root.u.def.section->owner;
  1473.       h->root.root.type = bfd_link_hash_undefined;
  1474.       h->root.root.u.undef.abfd = sub;
  1475.     }
  1476.       else
  1477.     {
  1478.       /* This symbol is in the .text section.  We must give it an
  1479.          entry in the procedure linkage table, if we have not
  1480.          already done so.  We change the definition of the symbol
  1481.          to the .plt section; this will cause relocs against it to
  1482.          be handled correctly.  */
  1483.       if (h->root.root.u.def.section != splt)
  1484.         {
  1485.           if (splt->_raw_size == 0)
  1486.         splt->_raw_size = SPARC_PLT_ENTRY_SIZE;
  1487.           h->root.root.u.def.section = splt;
  1488.           h->root.root.u.def.value = splt->_raw_size;
  1489.           splt->_raw_size += SPARC_PLT_ENTRY_SIZE;
  1490.  
  1491.           /* We will also need a dynamic reloc entry.  */
  1492.           srel->_raw_size += RELOC_EXT_SIZE;
  1493.         }
  1494.     }
  1495.     }
  1496.  
  1497.   return true;
  1498. }
  1499.  
  1500. /* Build the hash table of dynamic symbols, and to mark as written all
  1501.    symbols from dynamic objects which we do not plan to write out.  */
  1502.  
  1503. static boolean
  1504. sunos_scan_dynamic_symbol (h, data)
  1505.      struct sunos_link_hash_entry *h;
  1506.      PTR data;
  1507. {
  1508.   struct bfd_link_info *info = (struct bfd_link_info *) data;
  1509.  
  1510.   /* Set the written flag for symbols we do not want to write out as
  1511.      part of the regular symbol table.  This is all symbols which are
  1512.      not defined in a regular object file.  For some reason symbols
  1513.      which are referenced by a regular object and defined by a dynamic
  1514.      object do not seem to show up in the regular symbol table.  */
  1515.   if ((h->flags & SUNOS_DEF_REGULAR) == 0)
  1516.     h->root.written = true;
  1517.  
  1518.   /* If this symbol is defined by a dynamic object and referenced by a
  1519.      regular object, see whether we gave it a reasonable value while
  1520.      scanning the relocs.  */
  1521.  
  1522.   if ((h->flags & SUNOS_DEF_REGULAR) == 0
  1523.       && (h->flags & SUNOS_DEF_DYNAMIC) != 0
  1524.       && (h->flags & SUNOS_REF_REGULAR) != 0)
  1525.     {
  1526.       if (h->root.root.type == bfd_link_hash_defined
  1527.       && ((h->root.root.u.def.section->owner->flags & DYNAMIC) != 0)
  1528.       && h->root.root.u.def.section->output_section == NULL)
  1529.     {
  1530.       bfd *sub;
  1531.  
  1532.       /* This symbol is currently defined in a dynamic section
  1533.          which is not being put into the output file.  This
  1534.          implies that there is no reloc against the symbol.  I'm
  1535.          not sure why this case would ever occur.  In any case, we
  1536.          change the symbol to be undefined.  */
  1537.       sub = h->root.root.u.def.section->owner;
  1538.       h->root.root.type = bfd_link_hash_undefined;
  1539.       h->root.root.u.undef.abfd = sub;
  1540.     }
  1541.     }
  1542.  
  1543.   /* If this symbol is defined or referenced by a regular file, add it
  1544.      to the dynamic symbols.  */
  1545.   if ((h->flags & (SUNOS_DEF_REGULAR | SUNOS_REF_REGULAR)) != 0)
  1546.     {
  1547.       asection *s;
  1548.       size_t len;
  1549.       bfd_byte *contents;
  1550.       unsigned char *name;
  1551.       unsigned long hash;
  1552.       bfd *dynobj;
  1553.  
  1554.       BFD_ASSERT (h->dynindx == -2);
  1555.  
  1556.       h->dynindx = sunos_hash_table (info)->dynsymcount;
  1557.       ++sunos_hash_table (info)->dynsymcount;
  1558.  
  1559.       len = strlen (h->root.root.root.string);
  1560.  
  1561.       /* We don't bother to construct a BFD hash table for the strings
  1562.      which are the names of the dynamic symbols.  Using a hash
  1563.      table for the regular symbols is beneficial, because the
  1564.      regular symbols includes the debugging symbols, which have
  1565.      long names and are often duplicated in several object files.
  1566.      There are no debugging symbols in the dynamic symbols.  */
  1567.       s = bfd_get_section_by_name (sunos_hash_table (info)->dynobj,
  1568.                    ".dynstr");
  1569.       BFD_ASSERT (s != NULL);
  1570.       if (s->contents == NULL)
  1571.     contents = (bfd_byte *) malloc (len + 1);
  1572.       else
  1573.     contents = (bfd_byte *) realloc (s->contents, s->_raw_size + len + 1);
  1574.       if (contents == NULL)
  1575.     {
  1576.       bfd_set_error (bfd_error_no_memory);
  1577.       return false;
  1578.     }
  1579.       s->contents = contents;
  1580.  
  1581.       h->dynstr_index = s->_raw_size;
  1582.       strcpy (contents + s->_raw_size, h->root.root.root.string);
  1583.       s->_raw_size += len + 1;
  1584.  
  1585.       /* Add it to the dynamic hash table.  */
  1586.       name = (unsigned char *) h->root.root.root.string;
  1587.       hash = 0;
  1588.       while (*name != '\0')
  1589.     hash = (hash << 1) + *name++;
  1590.       hash &= 0x7fffffff;
  1591.       hash %= sunos_hash_table (info)->bucketcount;
  1592.  
  1593.       dynobj = sunos_hash_table (info)->dynobj;
  1594.       s = bfd_get_section_by_name (dynobj, ".hash");
  1595.       BFD_ASSERT (s != NULL);
  1596.  
  1597.       if (GET_SWORD (dynobj, s->contents + hash * HASH_ENTRY_SIZE) == -1)
  1598.     PUT_WORD (dynobj, h->dynindx, s->contents + hash * HASH_ENTRY_SIZE);
  1599.       else
  1600.     {
  1601.       bfd_vma next;
  1602.  
  1603.       next = GET_WORD (dynobj,
  1604.                (s->contents
  1605.                 + hash * HASH_ENTRY_SIZE
  1606.                 + BYTES_IN_WORD));
  1607.       PUT_WORD (dynobj, s->_raw_size / HASH_ENTRY_SIZE,
  1608.             s->contents + hash * HASH_ENTRY_SIZE + BYTES_IN_WORD);
  1609.       PUT_WORD (dynobj, h->dynindx, s->contents + s->_raw_size);
  1610.       PUT_WORD (dynobj, next, s->contents + s->_raw_size + BYTES_IN_WORD);
  1611.       s->_raw_size += HASH_ENTRY_SIZE;
  1612.     }
  1613.     }
  1614.  
  1615.   return true;
  1616. }
  1617.  
  1618. /* Link a dynamic object.  We actually don't have anything to do at
  1619.    this point.  This entry point exists to prevent the regular linker
  1620.    code from doing anything with the object.  */
  1621.  
  1622. /*ARGSUSED*/
  1623. static boolean
  1624. sunos_link_dynamic_object (info, abfd)
  1625.      struct bfd_link_info *info;
  1626.      bfd *abfd;
  1627. {
  1628.   return true;
  1629. }
  1630.  
  1631.  
  1632. /* Write out a dynamic symbol.  This is called by the final traversal
  1633.    over the symbol table.  */
  1634.  
  1635. static boolean
  1636. sunos_write_dynamic_symbol (output_bfd, info, harg)
  1637.      bfd *output_bfd;
  1638.      struct bfd_link_info *info;
  1639.      struct aout_link_hash_entry *harg;
  1640. {
  1641.   struct sunos_link_hash_entry *h = (struct sunos_link_hash_entry *) harg;
  1642.   boolean plt;
  1643.   int type;
  1644.   bfd_vma val;
  1645.   asection *s;
  1646.   struct external_nlist *outsym;
  1647.  
  1648.   if (h->dynindx < 0)
  1649.     return true;
  1650.  
  1651.   plt = false;
  1652.   switch (h->root.root.type)
  1653.     {
  1654.     default:
  1655.     case bfd_link_hash_new:
  1656.       abort ();
  1657.       /* Avoid variable not initialized warnings.  */
  1658.       return true;
  1659.     case bfd_link_hash_undefined:
  1660.       type = N_UNDF | N_EXT;
  1661.       val = 0;
  1662.       break;
  1663.     case bfd_link_hash_defined:
  1664.       {
  1665.     asection *sec;
  1666.     asection *output_section;
  1667.  
  1668.     sec = h->root.root.u.def.section;
  1669.     output_section = sec->output_section;
  1670.     BFD_ASSERT (bfd_is_abs_section (output_section)
  1671.             || output_section->owner == output_bfd);
  1672.     if (strcmp (sec->name, ".plt") == 0)
  1673.       {
  1674.         plt = true;
  1675.         type = N_UNDF | N_EXT;
  1676.         val = 0;
  1677.       }
  1678.     else
  1679.       {
  1680.         if (output_section == obj_textsec (output_bfd))
  1681.           type = N_TEXT | N_EXT;
  1682.         else if (output_section == obj_datasec (output_bfd))
  1683.           type = N_DATA | N_EXT;
  1684.         else if (output_section == obj_bsssec (output_bfd))
  1685.           type = N_BSS | N_EXT;
  1686.         else
  1687.           type = N_ABS | N_EXT;
  1688.         val = (h->root.root.u.def.value
  1689.            + output_section->vma
  1690.            + sec->output_offset);
  1691.       }
  1692.       }
  1693.       break;
  1694.     case bfd_link_hash_common:
  1695.       type = N_UNDF | N_EXT;
  1696.       val = h->root.root.u.c.size;
  1697.       break;
  1698.     case bfd_link_hash_weak:
  1699.       type = N_WEAKU;
  1700.       val = 0;
  1701.       break;
  1702.     case bfd_link_hash_indirect:
  1703.     case bfd_link_hash_warning:
  1704.       /* FIXME: Ignore these for now.  The circumstances under which
  1705.      they should be written out are not clear to me.  */
  1706.       return true;
  1707.     }
  1708.  
  1709.   s = bfd_get_section_by_name (sunos_hash_table (info)->dynobj, ".dynsym");
  1710.   BFD_ASSERT (s != NULL);
  1711.   outsym = ((struct external_nlist *)
  1712.         (s->contents + h->dynindx * EXTERNAL_NLIST_SIZE));
  1713.  
  1714.   bfd_h_put_8 (output_bfd, type, outsym->e_type);
  1715.   bfd_h_put_8 (output_bfd, 0, outsym->e_other);
  1716.  
  1717.   /* FIXME: The native linker doesn't use 0 for desc.  It seems to use
  1718.      one less than the desc value in the shared library, although that
  1719.      seems unlikely.  */
  1720.   bfd_h_put_16 (output_bfd, 0, outsym->e_desc);
  1721.  
  1722.   PUT_WORD (output_bfd, h->dynstr_index, outsym->e_strx);
  1723.   PUT_WORD (output_bfd, val, outsym->e_value);
  1724.  
  1725.   /* If this symbol is in the procedure linkage table, fill in the
  1726.      table entry.  */
  1727.   if (plt)
  1728.     {
  1729.       bfd_byte *p;
  1730.       asection *s;
  1731.       bfd_vma r_address;
  1732.  
  1733.       p = h->root.root.u.def.section->contents + h->root.root.u.def.value;
  1734.  
  1735.       s = bfd_get_section_by_name (sunos_hash_table (info)->dynobj, ".dynrel");
  1736.       BFD_ASSERT (s != NULL);
  1737.  
  1738.       r_address = (h->root.root.u.def.section->output_section->vma
  1739.            + h->root.root.u.def.section->output_offset
  1740.            + h->root.root.u.def.value);
  1741.  
  1742.       switch (bfd_get_arch (output_bfd))
  1743.     {
  1744.     case bfd_arch_sparc:
  1745.       bfd_put_32 (output_bfd, SPARC_PLT_ENTRY_WORD0, p);
  1746.       bfd_put_32 (output_bfd,
  1747.               (SPARC_PLT_ENTRY_WORD1
  1748.                + (((- (h->root.root.u.def.value + 4) >> 2)
  1749.                & 0x3fffffff))),
  1750.               p + 4);
  1751.       bfd_put_32 (output_bfd, SPARC_PLT_ENTRY_WORD2 + s->reloc_count,
  1752.               p + 8);
  1753.       break;
  1754.  
  1755.     case bfd_arch_m68k:
  1756.       bfd_put_16 (output_bfd, M68K_PLT_ENTRY_WORD0, p);
  1757.       bfd_put_32 (output_bfd, (- (h->root.root.u.def.value + 2)), p + 2);
  1758.       bfd_put_16 (output_bfd, s->reloc_count, p + 6);
  1759.       r_address += 2;
  1760.       break;
  1761.  
  1762.     default:
  1763.       abort ();
  1764.     }
  1765.  
  1766.       /* We also need to add a jump table reloc.  */
  1767.       p = s->contents + s->reloc_count * obj_reloc_entry_size (output_bfd);
  1768.       if (obj_reloc_entry_size (output_bfd) == RELOC_STD_SIZE)
  1769.     {
  1770.       struct reloc_std_external *srel;
  1771.  
  1772.       srel = (struct reloc_std_external *) p;
  1773.       PUT_WORD (output_bfd, r_address, srel->r_address);
  1774.       if (output_bfd->xvec->header_byteorder_big_p)
  1775.         {
  1776.           srel->r_index[0] = h->dynindx >> 16;
  1777.           srel->r_index[1] = h->dynindx >> 8;
  1778.           srel->r_index[2] = h->dynindx;
  1779.           srel->r_type[0] = (RELOC_STD_BITS_EXTERN_BIG
  1780.                  | RELOC_STD_BITS_JMPTABLE_BIG);
  1781.         }
  1782.       else
  1783.         {
  1784.           srel->r_index[2] = h->dynindx >> 16;
  1785.           srel->r_index[1] = h->dynindx >> 8;
  1786.           srel->r_index[0] = h->dynindx;
  1787.           srel->r_type[0] = (RELOC_STD_BITS_EXTERN_LITTLE
  1788.                  | RELOC_STD_BITS_JMPTABLE_LITTLE);
  1789.         }
  1790.     }
  1791.       else
  1792.     {
  1793.       struct reloc_ext_external *erel;
  1794.  
  1795.       erel = (struct reloc_ext_external *) p;
  1796.       PUT_WORD (output_bfd, r_address, erel->r_address);
  1797.       if (output_bfd->xvec->header_byteorder_big_p)
  1798.         {
  1799.           erel->r_index[0] = h->dynindx >> 16;
  1800.           erel->r_index[1] = h->dynindx >> 8;
  1801.           erel->r_index[2] = h->dynindx;
  1802.           erel->r_type[0] = (RELOC_EXT_BITS_EXTERN_BIG
  1803.                  | (22 << RELOC_EXT_BITS_TYPE_SH_BIG));
  1804.         }
  1805.       else
  1806.         {
  1807.           erel->r_index[2] = h->dynindx >> 16;
  1808.           erel->r_index[1] = h->dynindx >> 8;
  1809.           erel->r_index[0] = h->dynindx;
  1810.           erel->r_type[0] = (RELOC_EXT_BITS_EXTERN_LITTLE
  1811.                  | (22 << RELOC_EXT_BITS_TYPE_SH_LITTLE));
  1812.         }
  1813.       PUT_WORD (output_bfd, (bfd_vma) 0, erel->r_addend);
  1814.     }
  1815.  
  1816.       ++s->reloc_count;
  1817.     }
  1818.  
  1819.   return true;
  1820. }
  1821.  
  1822. /* This is called for each reloc against an external symbol.  If this
  1823.    is a reloc which are are going to copy as a dynamic reloc, then
  1824.    copy it over, and tell the caller to not bother processing this
  1825.    reloc.  */
  1826.  
  1827. /*ARGSUSED*/
  1828. static boolean
  1829. sunos_check_dynamic_reloc (info, input_bfd, input_section, harg, reloc, skip)
  1830.      struct bfd_link_info *info;
  1831.      bfd *input_bfd;
  1832.      asection *input_section;
  1833.      struct aout_link_hash_entry *harg;
  1834.      PTR reloc;
  1835.      boolean *skip;
  1836. {
  1837.   struct sunos_link_hash_entry *h = (struct sunos_link_hash_entry *) harg;
  1838.   bfd *dynobj;
  1839.   asection *srel;
  1840.   bfd_byte *p;
  1841.  
  1842.   *skip = false;
  1843.  
  1844.   dynobj = sunos_hash_table (info)->dynobj;
  1845.  
  1846.   if (dynobj == NULL
  1847.       || h->dynindx == -1
  1848.       || h->root.root.type != bfd_link_hash_undefined
  1849.       || (h->flags & SUNOS_DEF_REGULAR) != 0
  1850.       || (h->flags & SUNOS_DEF_DYNAMIC) == 0
  1851.       || (h->root.root.u.undef.abfd->flags & DYNAMIC) == 0)
  1852.     return true;
  1853.  
  1854.   /* It looks this is a reloc we are supposed to copy.  */
  1855.  
  1856.   srel = bfd_get_section_by_name (dynobj, ".dynrel");
  1857.   BFD_ASSERT (srel != NULL);
  1858.  
  1859.   p = srel->contents + srel->reloc_count * obj_reloc_entry_size (dynobj);
  1860.  
  1861.   /* Copy the reloc over.  */
  1862.   memcpy (p, reloc, obj_reloc_entry_size (dynobj));
  1863.  
  1864.   /* Adjust the address and symbol index.  */
  1865.   if (obj_reloc_entry_size (dynobj) == RELOC_STD_SIZE)
  1866.     {
  1867.       struct reloc_std_external *srel;
  1868.  
  1869.       srel = (struct reloc_std_external *) p;
  1870.       PUT_WORD (dynobj,
  1871.         (GET_WORD (dynobj, srel->r_address)
  1872.          + input_section->output_section->vma
  1873.          + input_section->output_offset),
  1874.         srel->r_address);
  1875.       if (dynobj->xvec->header_byteorder_big_p)
  1876.     {
  1877.       srel->r_index[0] = h->dynindx >> 16;
  1878.       srel->r_index[1] = h->dynindx >> 8;
  1879.       srel->r_index[2] = h->dynindx;
  1880.     }
  1881.       else
  1882.     {
  1883.       srel->r_index[2] = h->dynindx >> 16;
  1884.       srel->r_index[1] = h->dynindx >> 8;
  1885.       srel->r_index[0] = h->dynindx;
  1886.     }
  1887.     }
  1888.   else
  1889.     {
  1890.       struct reloc_ext_external *erel;
  1891.  
  1892.       erel = (struct reloc_ext_external *) p;
  1893.       PUT_WORD (dynobj,
  1894.         (GET_WORD (dynobj, erel->r_address)
  1895.          + input_section->output_section->vma
  1896.          + input_section->output_offset),
  1897.         erel->r_address);
  1898.       if (dynobj->xvec->header_byteorder_big_p)
  1899.     {
  1900.       erel->r_index[0] = h->dynindx >> 16;
  1901.       erel->r_index[1] = h->dynindx >> 8;
  1902.       erel->r_index[2] = h->dynindx;
  1903.     }
  1904.       else
  1905.     {
  1906.       erel->r_index[2] = h->dynindx >> 16;
  1907.       erel->r_index[1] = h->dynindx >> 8;
  1908.       erel->r_index[0] = h->dynindx;
  1909.     }
  1910.     }
  1911.  
  1912.   ++srel->reloc_count;
  1913.  
  1914.   *skip = true;
  1915.  
  1916.   return true;
  1917. }
  1918.  
  1919. /* Finish up the dynamic linking information.  */
  1920.  
  1921. static boolean
  1922. sunos_finish_dynamic_link (abfd, info)
  1923.      bfd *abfd;
  1924.      struct bfd_link_info *info;
  1925. {
  1926.   bfd *dynobj;
  1927.   asection *o;
  1928.   asection *s;
  1929.   asection *sdyn;
  1930.   struct external_sun4_dynamic esd;
  1931.   struct external_sun4_dynamic_link esdl;
  1932.  
  1933.   dynobj = sunos_hash_table (info)->dynobj;
  1934.   if (dynobj == NULL)
  1935.     return true;
  1936.  
  1937.   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
  1938.   BFD_ASSERT (sdyn != NULL);
  1939.  
  1940.   /* Finish up the .need section.  The linker emulation code filled it
  1941.      in, but with offsets from the start of the section instead of
  1942.      real addresses.  Now that we know the section location, we can
  1943.      fill in the final values.  */
  1944.   s = bfd_get_section_by_name (dynobj, ".need");
  1945.   BFD_ASSERT (s != NULL);
  1946.   if (s->_raw_size != 0)
  1947.     {
  1948.       file_ptr filepos;
  1949.       bfd_byte *p;
  1950.  
  1951.       filepos = s->output_section->filepos + s->output_offset;
  1952.       p = s->contents;
  1953.       while (1)
  1954.     {
  1955.       bfd_vma val;
  1956.  
  1957.       PUT_WORD (dynobj, GET_WORD (dynobj, p) + filepos, p);
  1958.       val = GET_WORD (dynobj, p + 12);
  1959.       if (val == 0)
  1960.         break;
  1961.       PUT_WORD (dynobj, val + filepos, p + 12);
  1962.       p += 16;
  1963.     }
  1964.     }
  1965.  
  1966.   /* The first entry in the .got section is the address of the dynamic
  1967.      information.  */
  1968.   s = bfd_get_section_by_name (dynobj, ".got");
  1969.   BFD_ASSERT (s != NULL);
  1970.   PUT_WORD (dynobj, sdyn->output_section->vma + sdyn->output_offset,
  1971.         s->contents);
  1972.  
  1973.   for (o = dynobj->sections; o != NULL; o = o->next)
  1974.     {
  1975.       if ((o->flags & SEC_HAS_CONTENTS) != 0
  1976.       && o->contents != NULL)
  1977.     {
  1978.       BFD_ASSERT (o->output_section != NULL
  1979.               && o->output_section->owner == abfd);
  1980.       if (! bfd_set_section_contents (abfd, o->output_section,
  1981.                       o->contents, o->output_offset,
  1982.                       o->_raw_size))
  1983.         return false;
  1984.     }
  1985.     }
  1986.  
  1987.   /* Finish up the dynamic link information.  */
  1988.   PUT_WORD (dynobj, (bfd_vma) 3, esd.ld_version);
  1989.   PUT_WORD (dynobj,
  1990.         sdyn->output_section->vma + sdyn->output_offset + sizeof esd,
  1991.         esd.ldd);
  1992.   PUT_WORD (dynobj,
  1993.         (sdyn->output_section->vma
  1994.          + sdyn->output_offset
  1995.          + sizeof esd
  1996.          + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE),
  1997.         esd.ld);
  1998.  
  1999.   if (! bfd_set_section_contents (abfd, sdyn->output_section, &esd,
  2000.                   sdyn->output_offset, sizeof esd))
  2001.     return false;
  2002.  
  2003.  
  2004.   PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_loaded);
  2005.  
  2006.   s = bfd_get_section_by_name (dynobj, ".need");
  2007.   BFD_ASSERT (s != NULL);
  2008.   if (s->_raw_size == 0)
  2009.     PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_need);
  2010.   else
  2011.     PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
  2012.           esdl.ld_need);
  2013.  
  2014.   s = bfd_get_section_by_name (dynobj, ".rules");
  2015.   BFD_ASSERT (s != NULL);
  2016.   if (s->_raw_size == 0)
  2017.     PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_rules);
  2018.   else
  2019.     PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
  2020.           esdl.ld_rules);
  2021.  
  2022.   s = bfd_get_section_by_name (dynobj, ".got");
  2023.   BFD_ASSERT (s != NULL);
  2024.   PUT_WORD (dynobj, s->output_section->vma + s->output_offset, esdl.ld_got);
  2025.  
  2026.   s = bfd_get_section_by_name (dynobj, ".plt");
  2027.   BFD_ASSERT (s != NULL);
  2028.   PUT_WORD (dynobj, s->output_section->vma + s->output_offset, esdl.ld_plt);
  2029.   PUT_WORD (dynobj, s->_raw_size, esdl.ld_plt_sz);
  2030.  
  2031.   s = bfd_get_section_by_name (dynobj, ".dynrel");
  2032.   BFD_ASSERT (s != NULL);
  2033.   BFD_ASSERT (s->reloc_count * obj_reloc_entry_size (dynobj) == s->_raw_size);
  2034.   PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
  2035.         esdl.ld_rel);
  2036.  
  2037.   s = bfd_get_section_by_name (dynobj, ".hash");
  2038.   BFD_ASSERT (s != NULL);
  2039.   PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
  2040.         esdl.ld_hash);
  2041.  
  2042.   s = bfd_get_section_by_name (dynobj, ".dynsym");
  2043.   BFD_ASSERT (s != NULL);
  2044.   PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
  2045.         esdl.ld_stab);
  2046.  
  2047.   PUT_WORD (dynobj, (bfd_vma) 0, esdl.ld_stab_hash);
  2048.  
  2049.   PUT_WORD (dynobj, (bfd_vma) sunos_hash_table (info)->bucketcount,
  2050.         esdl.ld_buckets);
  2051.  
  2052.   s = bfd_get_section_by_name (dynobj, ".dynstr");
  2053.   BFD_ASSERT (s != NULL);
  2054.   PUT_WORD (dynobj, s->output_section->filepos + s->output_offset,
  2055.         esdl.ld_symbols);
  2056.   PUT_WORD (dynobj, s->_raw_size, esdl.ld_symb_size);
  2057.  
  2058.   /* The size of the text area is the size of the .text section
  2059.      rounded up to a page boundary.  FIXME: Should the page size be
  2060.      conditional on something?  */
  2061.   PUT_WORD (dynobj,
  2062.         BFD_ALIGN (obj_textsec (abfd)->_raw_size, 0x2000),
  2063.         esdl.ld_text);
  2064.   
  2065.   if (! bfd_set_section_contents (abfd, sdyn->output_section, &esdl,
  2066.                   (sdyn->output_offset
  2067.                    + sizeof esd
  2068.                    + EXTERNAL_SUN4_DYNAMIC_DEBUGGER_SIZE),
  2069.                   sizeof esdl))
  2070.     return false;
  2071.  
  2072.   abfd->flags |= DYNAMIC;
  2073.  
  2074.   return true;
  2075. }
  2076.